package SBD.CRUD;

import SBD.Servicios.Conexion;
import SBD.Servicios.FactoriaServicios;
import EP.MetricasContenido.SimilitudCoseno;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
* @class SimilitudCosenoBD
* @author Mauricio Alvarez.
* @brief Contiene los metodos CRUD a la BD para la métrica de similitud coseno.
*/
public class SimilitudCosenoBD
{

    //////////////////////////
    // OPERACIONES
    //////////////////////////

    public void GuardarSimilitudCoseno_P (int id_relacion_pagina, double pje_SCTF_IDF_N_TOTAL, double pje_SCTF_IDF_S_TOTAL) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        //Se guardan los parametros de la medición en la tabla Similitud_Coseno:
        cdb.un_sql = "UPDATE RELACION_PAGINAS SET PJE_PREDICTOR_SCTF_IDF_N = '" + pje_SCTF_IDF_N_TOTAL + "' WHERE ID_RELACION_PAG = '" + id_relacion_pagina + "';";
        cdb.un_st.executeUpdate(cdb.un_sql);
        
        cdb.un_sql = "UPDATE RELACION_PAGINAS SET PJE_PREDICTOR_SCTF_IDF_S = '" + pje_SCTF_IDF_S_TOTAL + "' WHERE ID_RELACION_PAG = '" + id_relacion_pagina + "';";
        cdb.un_st.executeUpdate(cdb.un_sql);        
        
    }
    
    
    
    /**
     * @brief Guarda los resultados de la medición de similitud coseno para el body.
     * @param El listado de los puntajes de todas las métricas de ranking, el TopicoConsultado, Umbral y Ranking.
     * @return void
    */
    public void GuardarSimilitudCoseno(Map<Integer, List> ResultadosSCTF_SN, 
                                       Map<Integer, List> ResultadosSCTF_N,
                                       Map<Integer, List> ResultadosSCTF_S,
                                       Map<Integer, List> ResultadosSCTFIDF_SN,
                                       Map<Integer, List> ResultadosSCTFIDF_N,
                                       Map<Integer, List> ResultadosSCTFIDF_S,
                                       Map<Integer, List> ResultadosSCTFIDF_O_SN,
                                       Map<Integer, List> ResultadosSCTFIDF_O_N,
                                       Map<Integer, List> ResultadosSCTFIDF_O_S,
                                       Map<Integer, List> ResultadosSCOKAPI,
                                       String TopicoConsultado,
                                       double Umbral,
                                       int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {

        //Atributos:
        int id_pagina;
        String termino;
        int id_pagina_objetivo;
        String url_test;
        String url_objetivo;
        double valor_sc;

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        //Se guardan los parametros de la medición en la tabla Similitud_Coseno:
        cdb.un_sql = "INSERT INTO SIMILITUD_COSENO(termino, umbral, ranking) VALUES"
                + "('" + TopicoConsultado + "','" +  Umbral + "','" + Ranking + "')";
        cdb.un_st.executeUpdate(cdb.un_sql);
        //El ultimo registro ingresado a la Tabla:
        cdb.un_sql = "SELECT id_sc FROM SIMILITUD_COSENO ORDER BY id_sc DESC LIMIT 1";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                //Se obtiene el id correspondiente a la medicion sc:
                int id_sc = cdb.resultado.getInt("id_sc");


                //Se guardan los resultados de la medición:
                ////////////////////////////////
                // (1) Similitud Coseno TF_SN
                ////////////////////////////////

                Set set = ResultadosSCTF_SN.entrySet();
                Iterator iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTF_SN = new ArrayList();
                    ListaSCTF_SN = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTF_SN.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSCTF_SN.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTF_SN.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTF_SN("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctf_sn) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas


                ////////////////////////////////
                // (2) Similitud Coseno TF_N
                ////////////////////////////////
                set = ResultadosSCTF_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTF_N = new ArrayList();
                    ListaSCTF_N = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTF_N.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTF_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTF_N.get(i).getUrl_test();
                        url_objetivo = ListaSCTF_N.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTF_N.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTF_N("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctf_n) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                ////////////////////////////////
                // (3) Similitud Coseno TF_S
                ////////////////////////////////
                set = ResultadosSCTF_S.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTF_S = new ArrayList();
                    ListaSCTF_S = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTF_S.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTF_S.get(i).getUrl_test();
                        url_objetivo = ListaSCTF_S.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTF_S.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTF_S("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctf_s) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                //////////////////////////////////
                // (4) Similitud Coseno TFIDF_SN
                //////////////////////////////////
                set = ResultadosSCTFIDF_SN.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_SN = new ArrayList();
                    ListaSCTFIDF_SN = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTFIDF_SN.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTFIDF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_SN.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_SN.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_SN("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_sn) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                //////////////////////////////////
                // (5) Similitud Coseno TFIDF_N
                //////////////////////////////////
                set = ResultadosSCTFIDF_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_N = new ArrayList();
                    ListaSCTFIDF_N = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTFIDF_N.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTFIDF_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_N.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_N.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_N.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_N("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_n) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                //////////////////////////////////
                // (6) Similitud Coseno TFIDF_S
                //////////////////////////////////
                set = ResultadosSCTFIDF_S.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_S = new ArrayList();
                    ListaSCTFIDF_S = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTFIDF_S.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTFIDF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_S.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_S.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_S.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_S("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_s) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas




                ////////////////////////////////////
                // (7) Similitud Coseno TFIDF_O_SN
                ////////////////////////////////////
                set = ResultadosSCTFIDF_O_SN.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_O_SN = new ArrayList();
                    ListaSCTFIDF_O_SN = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_O_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTFIDF_O_SN.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTFIDF_O_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_O_SN.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_O_SN.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_O_SN.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_O_SN("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_o_sn) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas




                ////////////////////////////////////
                // (8) Similitud Coseno TFIDF_O_N
                ////////////////////////////////////
                set = ResultadosSCTFIDF_O_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_O_N = new ArrayList();
                    ListaSCTFIDF_O_N = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_O_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTFIDF_O_N.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTFIDF_O_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_O_N.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_O_N.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_O_N.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_O_N("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_o_n) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas




                ////////////////////////////////////
                // (9) Similitud Coseno TFIDF_O_S
                ////////////////////////////////////
                set = ResultadosSCTFIDF_O_N.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_O_S = new ArrayList();
                    ListaSCTFIDF_O_S = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_O_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCTFIDF_O_S.get(i).getTermino();
                        id_pagina_objetivo = ListaSCTFIDF_O_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_O_S.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_O_S.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_O_S.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_O_S("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_o_s) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                ////////////////////////////////////
                // (10) Similitud Coseno OKAPI
                ////////////////////////////////////
                set = ResultadosSCOKAPI.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_pagina:
                    id_pagina = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCOKAPI = new ArrayList();
                    ListaSCOKAPI = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCOKAPI.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        termino = ListaSCOKAPI.get(i).getTermino();
                        id_pagina_objetivo = ListaSCOKAPI.get(i).getId_pagina_objetivo();
                        url_test = ListaSCOKAPI.get(i).getUrl_test();
                        url_objetivo = ListaSCOKAPI.get(i).getUrl_objetivo();
                        valor_sc = ListaSCOKAPI.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCOKAPI("
                                + "id_pagina, "
                                + "id_sc, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "scokapi) "
                                + "VALUES ('" + id_pagina + "','"
                                              + id_sc + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas


            }//FIN if
        }

    }//FIN GuardarSimilitudCoseno


    /**
     * @brief Rankea los resultados obtenidos por la medición coseno para las páginas.
     * @param Cantidad en el Ranking y la Consulta .
     * @return void
    */
    public void RankearMedicionSC(int Ranking, String Consulta) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////
        //PASO 1: Se cargan las páginas segun ranking y umbral
        ////////////////////////////////////////////////////////
        int rankeo  = 1;
        int contador = 0;
        //Almacena <id_pagina, rankeo>:
        HashMap<Integer,Integer> RankingPagina;
        //Fecha actual:
        java.util.Date fecha = new Date();


        ///////////////////////
        // (1) PARA SCTF_SN
        ///////////////////////

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTF_SN ORDER BY sctf_sn DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctf_sn = cdb.resultado.getDouble("sctf_sn");

                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTF_SN.");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTF_SN(RankingPagina);


        ///////////////////////
        // (2) PARA SCTF_N
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTF_N ORDER BY sctf_n DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctf_n = cdb.resultado.getDouble("sctf_n");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTF_N.");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTF_N(RankingPagina);


        ///////////////////////
        // (3) PARA SCTF_S
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTF_S ORDER BY sctf_s DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctf_s = cdb.resultado.getDouble("sctf_s");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTF_S.");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTF_S(RankingPagina);


        /////////////////////////
        // (4) PARA SCTFIDF_SN
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_SN ORDER BY sctfidf_sn DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_sn = cdb.resultado.getDouble("sctfidf_sn");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_SN .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_SN (RankingPagina);


        /////////////////////////
        // (5) PARA SCTFIDF_N
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_N ORDER BY sctfidf_n DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_n = cdb.resultado.getDouble("sctfidf_n");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_N .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_N(RankingPagina);



        /////////////////////////
        // (6) PARA SCTFIDF_S
        /////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_S ORDER BY sctfidf_s DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_s = cdb.resultado.getDouble("sctfidf_s");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_S .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_S(RankingPagina);



        ////////////////////////////
        // (7) PARA SCTFIDF_O_SN
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_O_SN ORDER BY sctfidf_o_sn DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_o_sn = cdb.resultado.getDouble("sctfidf_o_sn");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_O_SN .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_O_SN(RankingPagina);



        ////////////////////////////
        // (8) PARA SCTFIDF_O_N
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_O_N ORDER BY sctfidf_o_n DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_o_n = cdb.resultado.getDouble("sctfidf_o_n");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_O_N .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_O_N(RankingPagina);



        ////////////////////////////
        // (9) PARA SCTFIDF_O_S
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_O_S ORDER BY sctfidf_o_s DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_o_s = cdb.resultado.getDouble("sctfidf_o_s");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_O_S .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_O_S(RankingPagina);



        ////////////////////////////
        // (10) PARA SCOKAPI
        ////////////////////////////
        rankeo  = 1;
        contador = 0;
        
        //Almacena <id_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCOKAPI ORDER BY scokapi DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se setean los atributos de la tabla:
                   int id_pagina = cdb.resultado.getInt("id_pagina");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double scokapi = cdb.resultado.getDouble("scokapi");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_pagina, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCOKAPI .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCOKAPI(RankingPagina);


        
    }//FIN RankearMedicionSC



    private void ActualizarRankingSCTF_SN(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTF_SN SET ranking_sctf_sn = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTF_SN

    private void ActualizarRankingSCTF_N(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTF_N SET ranking_sctf_n = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTF_N

    private void ActualizarRankingSCTF_S(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTF_S SET ranking_sctf_s = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTF_S

    private void ActualizarRankingSCTFIDF_SN(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_SN SET ranking_sctfidf_sn = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_SN

    private void ActualizarRankingSCTFIDF_N(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_N SET ranking_sctfidf_n = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_N

    private void ActualizarRankingSCTFIDF_S(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_S SET ranking_sctfidf_s = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_S

    private void ActualizarRankingSCTFIDF_O_SN(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_O_SN SET ranking_sctfidf_o_sn = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_O_SN

    private void ActualizarRankingSCTFIDF_O_N(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_O_N SET ranking_sctfidf_o_n = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_O_N

    private void ActualizarRankingSCTFIDF_O_S(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_O_S SET ranking_sctfidf_o_s = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_O_S

    private void ActualizarRankingSCOKAPI(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCOKAPI SET ranking_scokapi = '" + me.getValue() + "' WHERE id_pagina = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCOKAPI


    /**
     * @brief Guarda los resultados de la medición de similitud coseno para el texto alrededor.
     * @param El listado de los puntajes de todas las métricas de ranking, el TopicoConsultado, Umbral y Ranking.
     * @return void
    */
    public void GuardarSimilitudCoseno_ST(Map<Integer, List> ResultadosSCTF_SN_ST,
                                          Map<Integer, List> ResultadosSCTF_N_ST,
                                          Map<Integer, List> ResultadosSCTF_S_ST,
                                          Map<Integer, List> ResultadosSCTFIDF_SN_ST,
                                          Map<Integer, List> ResultadosSCTFIDF_N_ST,
                                          Map<Integer, List> ResultadosSCTFIDF_S_ST,
                                          Map<Integer, List> ResultadosSCTFIDF_O_SN_ST,
                                          Map<Integer, List> ResultadosSCTFIDF_O_N_ST,
                                          Map<Integer, List> ResultadosSCTFIDF_O_S_ST,
                                          Map<Integer, List> ResultadosSCOKAPI_ST,
                                          String TopicoConsultado,
                                          double Umbral,
                                          int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {

        //Atributos:
        int id_relacion_pag;
        int id_pagina_objetivo;
        String url_test;
        String url_objetivo;
        String termino;
        double valor_sc;

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        //Se guardan los parametros de la medición en la tabla Similitud_Coseno ST:
        cdb.un_sql = "INSERT INTO SIMILITUD_COSENO_ST (termino, umbral, ranking) VALUES"
                + "('" + TopicoConsultado + "','" +  Umbral + "','" + Ranking + "')";
        cdb.un_st.executeUpdate(cdb.un_sql);
        //El ultimo registro ingresado a la Tabla:
        cdb.un_sql = "SELECT id_sc_st FROM SIMILITUD_COSENO_ST ORDER BY id_sc_st DESC LIMIT 1";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                //Se obtiene el id correspondiente a la medicion sc:
                int id_sc_st = cdb.resultado.getInt("id_sc_st");


                //Se guardan los resultados de la medición:
                ////////////////////////////////////
                // (1) Similitud Coseno TF_SN_ST
                ////////////////////////////////////

                Set set = ResultadosSCTF_SN_ST.entrySet();
                Iterator iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTF_SN = new ArrayList();
                    ListaSCTF_SN = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSCTF_SN.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTF_SN.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTF_SN_ST("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctf_sn_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc_st

                }//FIN while páginas


                ////////////////////////////////////////////
                // (2) Similitud Coseno TF_N_ST
                ////////////////////////////////////////////
                set = ResultadosSCTF_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTF_N = new ArrayList();
                    ListaSCTF_N = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTF_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTF_N.get(i).getUrl_test();
                        url_objetivo = ListaSCTF_N.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTF_N.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTF_N_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctf_n_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                //////////////////////////////////////////////////
                // (3) Similitud Coseno TF_S_ST
                //////////////////////////////////////////////////
                set = ResultadosSCTF_S_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTF_S = new ArrayList();
                    ListaSCTF_S = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTF_S.get(i).getUrl_test();
                        url_objetivo = ListaSCTF_S.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTF_S.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTF_S_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctf_s_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                ////////////////////////////////////////////////////
                // (4) Similitud Coseno TFIDF_SN_ST
                ////////////////////////////////////////////////////
                set = ResultadosSCTFIDF_SN_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_SN = new ArrayList();
                    ListaSCTFIDF_SN = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTFIDF_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_SN.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_SN.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_SN.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_SN_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_sn_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                //////////////////////////////////////////////
                // (5) Similitud Coseno TFIDF_N_ST
                //////////////////////////////////////////////
                set = ResultadosSCTFIDF_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_N = new ArrayList();
                    ListaSCTFIDF_N = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTFIDF_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_N.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_N.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_N.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_N_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_n_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas




                ////////////////////////////////////////////////
                // (6) Similitud Coseno TFIDF_S_ST
                ////////////////////////////////////////////////
                set = ResultadosSCTFIDF_S_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_S = new ArrayList();
                    ListaSCTFIDF_S = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTFIDF_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_S.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_S.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_S.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_S_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_s_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas




                ///////////////////////////////////////////////////
                // (7) Similitud Coseno TFIDF_O_SN_ST
                ///////////////////////////////////////////////////
                set = ResultadosSCTFIDF_O_SN_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_O_SN = new ArrayList();
                    ListaSCTFIDF_O_SN = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_O_SN.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTFIDF_O_SN.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_O_SN.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_O_SN.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_O_SN.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_O_SN_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_o_sn_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas




                ////////////////////////////////////////////////////////////
                // (8) Similitud Coseno TFIDF_O_N_ST
                ////////////////////////////////////////////////////////////
                set = ResultadosSCTFIDF_O_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_O_N = new ArrayList();
                    ListaSCTFIDF_O_N = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_O_N.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTFIDF_O_N.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_O_N.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_O_N.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_O_N.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_O_N_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_o_n_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                //////////////////////////////////////////////////
                // (9) Similitud Coseno TFIDF_O_S_ST
                //////////////////////////////////////////////////
                set = ResultadosSCTFIDF_O_N_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCTFIDF_O_S = new ArrayList();
                    ListaSCTFIDF_O_S = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCTFIDF_O_S.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCTFIDF_O_S.get(i).getId_pagina_objetivo();
                        url_test = ListaSCTFIDF_O_S.get(i).getUrl_test();
                        url_objetivo = ListaSCTFIDF_O_S.get(i).getUrl_objetivo();
                        valor_sc = ListaSCTFIDF_O_S.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCTFIDF_O_S_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "sctfidf_o_s_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas



                ///////////////////////////////////////////////////
                // (10) Similitud Coseno OKAPI_ST
                ///////////////////////////////////////////////////
                set = ResultadosSCOKAPI_ST.entrySet();
                iter = set.iterator();

                while(iter.hasNext())
                {
                    //Se obtiene el par <id_pagina, ArrayList<SC>>
                    Map.Entry me = (Map.Entry)iter.next();
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = (Integer) me.getKey();
                    //Se obtiene el ArrayList<SC>:
                    List<SimilitudCoseno> ListaSCOKAPI = new ArrayList();
                    ListaSCOKAPI = (List<SimilitudCoseno>) me.getValue();

                    //Para cada página con sus puntajes hacer:
                    for (int i=0; i<ListaSCOKAPI.size(); i++)
                    {
                        //Se obtienen los valores a insertar:
                        id_pagina_objetivo = ListaSCOKAPI.get(i).getId_pagina_objetivo();
                        url_test = ListaSCOKAPI.get(i).getUrl_test();
                        url_objetivo = ListaSCOKAPI.get(i).getUrl_objetivo();
                        valor_sc = ListaSCOKAPI.get(i).getValor_sc();


                        //Se ingresan a la BD:
                        cdb.un_sql = "INSERT INTO MEDICION_SCOKAPI_ST ("
                                + "id_relacion_pag, "
                                + "id_sc_st, "
                                + "id_pagina_objetivo, "
                                + "url_test, "
                                + "url_objetivo, "
                                + "scokapi_st) "
                                + "VALUES ('" + id_relacion_pag + "','"
                                              + id_sc_st + "','"
                                              + id_pagina_objetivo + "','"
                                              + url_test + "','"
                                              + url_objetivo + "','"
                                              + valor_sc + "')";
                        cdb.un_st.executeUpdate(cdb.un_sql);

                    }//FIN for scores sc

                }//FIN while páginas


            }//FIN if
        }

    }//FIN GuardarSimilitudCoseno_ST


    /**
     * @brief Rankea los resultados obtenidos por la medición coseno para el texto alrededor.
     * @param Cantidad en el Ranking y la Consulta .
     * @return void
    */
    public void RankearMedicionSC_ST(int Ranking, String TopicoConsultado) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {

        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////
        //PASO 1: Se cargan las páginas segun ranking y umbral
        ////////////////////////////////////////////////////////
        int rankeo  = 1;
        int contador = 0;
        //Almacena <id_relacion_pag, rankeo>:
        HashMap<Integer,Integer> RankingPagina;
        //Fecha actual:
        java.util.Date fecha = new Date();


        ////////////////////////////////////////////////////////////////////////
        // (1) PARA SCTF_SN_ST
        ///////////////////////

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTF_SN_ST ORDER BY sctf_sn_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTF_SN_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctf_sn_st = cdb.resultado.getDouble("sctf_sn_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTF_SN_ST.");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTF_SN_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (2) PARA SCTF_N_ST
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTF_N_ST ORDER BY sctf_n_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctf_n_st = cdb.resultado.getDouble("sctf_n_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTF_N_ST.");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTF_N_ST(RankingPagina);


        ///////////////////////////////////////////////////////////////////////
        // (3) PARA SCTF_S_ST
        ///////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTF_S_ST ORDER BY sctf_s_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTF_S_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctf_s_st = cdb.resultado.getDouble("sctf_s_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTF_S_ST.");
                }

            }
            
        }

        // Se Actualiza el raking:
        ActualizarRankingSCTF_S_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (4) PARA SCTFIDF_SN_ST
        ///////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_SN_ST ORDER BY sctfidf_sn_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTFIDF_SN_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_sn_st = cdb.resultado.getDouble("sctfidf_sn_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_SN .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_SN_ST(RankingPagina);


        ////////////////////////////////////////////////////////////////////////
        // (5) PARA SCTFIDF_N_ST
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_N_ST ORDER BY sctfidf_n_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTFIDF_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_n_st = cdb.resultado.getDouble("sctfidf_n_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_N_ST.");
                }

            }
            
        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_N_ST(RankingPagina);



        ////////////////////////////////////////////////////////////////////////
        // (6) PARA SCTFIDF_S_ST
        //////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_S_ST ORDER BY sctfidf_s_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTFIDF_S_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_s_st = cdb.resultado.getDouble("sctfidf_s_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_S_ST.");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_S_ST(RankingPagina);



        ////////////////////////////////////////////////////////////////////////
        // (7) PARA SCTFIDF_O_SN_ST
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_O_SN_ST ORDER BY sctfidf_o_sn_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTFIDF_O_SN_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_o_sn_st = cdb.resultado.getDouble("sctfidf_o_sn_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_O_SN_ST .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_O_SN_ST(RankingPagina);



        ////////////////////////////////////////////////////////////////////////
        // (8) PARA SCTFIDF_O_N_ST
        ////////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_O_N_ST ORDER BY sctfidf_o_n_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTFIDF_O_N_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_o_n_st = cdb.resultado.getDouble("sctfidf_o_n_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_O_N_ST .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_O_N_ST(RankingPagina);



        ////////////////////////////////////////////////////////////////////////
        // (9) PARA SCTFIDF_O_S_ST
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pag, rankeo>:
        RankingPagina = new HashMap();

        cdb.un_sql = "SELECT * FROM MEDICION_SCTFIDF_O_S_ST ORDER BY sctfidf_o_s_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCTFIDF_O_S_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double sctfidf_o_s_st = cdb.resultado.getDouble("sctfidf_o_s_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCTFIDF_O_S_ST .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCTFIDF_O_S_ST(RankingPagina);



        ////////////////////////////////////////////////////////////////////////
        // (10) PARA SCOKAPI_ST
        ////////////////////////////
        rankeo  = 1;
        contador = 0;

        //Almacena <id_relacion_pagina, rankeo>:
        RankingPagina = new HashMap<Integer,Integer>();

        cdb.un_sql = "SELECT * FROM MEDICION_SCOKAPI_ST ORDER BY scokapi_st DESC";
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {

            while (cdb.resultado.next())
            {
                try {

                   //Se obtienen los campos de MEDICION_SCOKAPI_ST:
                   int id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                   int id_pagina_objetivo = cdb.resultado.getInt("id_pagina_objetivo");
                   String url_test = cdb.resultado.getString("url_test");
                   String url_objetivo = cdb.resultado.getString("url_objetivo");
                   double scokapi_st = cdb.resultado.getDouble("scokapi_st");


                   //Se escriben en el archivo de texto solo las k-mejores paginas pedidas por el usuario:
                   if (contador < Ranking)
                   {
                      contador++;
                   }

                   RankingPagina.put(id_relacion_pag, rankeo);
                   rankeo++;

                } catch (Exception e) {
                    System.out.println("ERROR: No se ha podido crear archivo Ranking SCOKAPI-ST .");
                }

            }

        }

        // Se Actualiza el raking:
        ActualizarRankingSCOKAPI_ST(RankingPagina);


    }//FIN RankearMedicionSC_ST



    private void ActualizarRankingSCTF_SN_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTF_SN_ST SET ranking_sctf_sn_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTF_SN_ST

    private void ActualizarRankingSCTF_N_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTF_N_ST SET ranking_sctf_n_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTF_N_ST

    private void ActualizarRankingSCTF_S_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTF_S_ST SET ranking_sctf_s_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTF_S_ST

    private void ActualizarRankingSCTFIDF_SN_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_SN_ST SET ranking_sctfidf_sn_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_SN_ST

    private void ActualizarRankingSCTFIDF_N_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_N_ST SET ranking_sctfidf_n_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_N_ST

    private void ActualizarRankingSCTFIDF_S_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_S_ST SET ranking_sctfidf_s_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_S_ST

    private void ActualizarRankingSCTFIDF_O_SN_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_O_SN_ST SET ranking_sctfidf_o_sn_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_O_SN_ST

    private void ActualizarRankingSCTFIDF_O_N_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_O_N_ST SET ranking_sctfidf_o_n_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_O_N_ST

    private void ActualizarRankingSCTFIDF_O_S_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCTFIDF_O_S_ST SET ranking_sctfidf_o_s_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCTFIDF_O_S_ST

    private void ActualizarRankingSCOKAPI_ST(HashMap<Integer, Integer> RankingPagina) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();
        Set set = RankingPagina.entrySet();
        Iterator i = set.iterator();

        while(i.hasNext())
        {
            Map.Entry me = (Map.Entry)i.next();
            cdb.un_sql = "UPDATE MEDICION_SCOKAPI_ST SET ranking_scokapi_st = '" + me.getValue() + "' WHERE id_relacion_pag = '" + me.getKey() +"';";
            cdb.un_st.executeUpdate(cdb.un_sql);
        }

    }//FIN ActualizarRankingSCOKAPI_ST


}//FIN CLASE SimilitudCosenoBD
